//package com.huawei.util;
//
//import com.alibaba.fastjson.JSONArray;
//import com.alibaba.fastjson.JSONException;
//import com.huawei.hutaf.apitest.aw.AWResponse;
//import com.huawei.hutaf.apitest.aw.FunctionSet;
//import com.huawei.hutaf.apitest.aw.Reporter;
//import org.apache.commons.collections.map.CaseInsensitiveMap;
//
//import java.sql.*;
//import java.util.*;
//import java.util.stream.Stream;
//
//
//public class JdbcUtilPerf {
//
//    public JdbcUtilPerf() {
//    }
//
//    //********************************************************************
//    /**
//     * @Description 获取数据库的链接（老方法：直接传入链接串、账号、密码）
//     * @param url: JDBC连接
//     * @param us: 数据库账号
//     * @param ps: 数据库密码
//     *********************************************************************/
//    public static Connection getConnection(String url, String us, String ps) {
//
//        Connection connection = null;
//        String dbtype = "";
//        try {
//            if (url.toLowerCase().indexOf("oracle") >= 0) {
//                dbtype = "oracle";
//                Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
//            }
//            if (url.toLowerCase().indexOf("mysql") >= 0) {
//                dbtype = "mysql";
//                Class.forName("com.mysql.jdbc.Driver").newInstance();
//            }
//            if (url.toLowerCase().indexOf("zenith") >= 0) {
//                dbtype = "gauss";
//                Class.forName("com.huawei.gauss.jdbc.ZenithDriver").newInstance();
//            }
//            // 精密时测
//            if (url.toLowerCase().indexOf("zenith") >= 0) {
//                dbtype = "zenith";
//
//                ----------------------------------------------------------------------------------------------------------
//
//                if (url.toLowerCase().indexOf("zenith") >= 0) {
//                    dbtype = "zenith";
//                    Class.forName("com.huawei.gauss.jdbc.inner.GaussDriver").newInstance();
//                }
//                if (url.toLowerCase().indexOf("opengauss") >= 0) {
//                    dbtype = "openGauss";
//                    Class.forName("com.huawei.opengauss.jdbc.Driver").newInstance();
//                }
//                if (url.toLowerCase().indexOf("gaussdb") >= 0) {
//                    dbtype = "GaussDB";
//                    Class.forName("com.huawei.gauss.jdbc.ZenithDriver").newInstance();
//                }
//                if (url.toLowerCase().indexOf("postgresql") >= 0) {
//                    dbtype = "postgresql";
//                    Class.forName("org.postgresql.Driver").newInstance();
//                }
//                connection = DriverManager.getConnection(url.trim(), us.trim(), ps.trim());
//            } catch (SQLException | ClassNotFoundException | InstantiationException | IllegalAccessException e) {
//                Reporter.log("1#数据库类型#" + dbtype, true);
//                Reporter.log("1#数据库URL#" + url, true);
//                Reporter.log("1#数据库账号#" + us, true);
//
//                if (url.contains("$")) {
//                    throw new NullPointerException("数据库URL未配置/引用错误，请检查！");
//                }
//                if (us.contains("$")) {
//                    throw new NullPointerException("数据库账号未配置/引用错误，请检查！");
//                }
//                if (ps.contains("$")) {
//                    throw new NullPointerException("数据库密码未配置/引用错误，请检查！");
//                }
//                Reporter.log("1#数据库连接失败#" + e.getMessage(), true);
//                e.printStackTrace();
//            }
//            return connection;
//        }
//    }
//
//    NullPointerException("数据库账号未配置/引用错误，请检查！");
//}
//
//            if (dbtype.isEmpty() || e.getMessage().contains("No suitable driver found")) {
//        throw new NullPointerException(e.getMessage() + " 找不到驱动，请检查url是否正确或代码仓lib目录是否有驱动包。");
//        }
//        if (e.getMessage().contains("Invalid username/password, login denied")) {
//        throw new NullPointerException(e.getMessage() + " 请检查账号/密码或密码数据类型(Ciphertext)是否正确。");
//        } else {
//        throw new NullPointerException("连接异常 " + e.getMessage() + " 请检查执行机访问数据库的网络是否畅通。");
//        }
////            printException("错误日志：", e);
//        }
//        Reporter.log("1#打开数据库连接#" + us + ":" + connection, true);
//        return connection;
//    }
//
////********************************************************************
///**
// * @Description 异常打印
// * @param key: 异常名称
// * @param e: 异常信息
// *********************************************************************/
//private static void printException(String key, Exception e) {
//    StackTraceElement[] stackTrace = e.getStackTrace();
//    StringBuilder trace = new StringBuilder();
//    Stream.of(stackTrace).forEach((x) -> {
//        trace.append(x.toString()).append(System.lineSeparator());
//    });
//
//    ----------------------------------------------------------------------------------------------------------
//
//            trace.append(x.toString()).append(System.lineSeparator());
//});
//        Reporter.log("1#" + key + "#" + trace.toString(), true);
//        }
//
////********************************************************************
///**
// * @Description 数据库关闭
// * @param pstmt: 关闭SQL语句处理命名
// * @param rs: 关闭结果集
// *********************************************************************/
//public static void close(PreparedStatement pstmt, ResultSet rs) {
//    try {
//        // 判断是否被操作
//        if (rs != null) {
//            rs.close();
//        }
//        if (pstmt != null) {
//            pstmt.close();
//        }
//    } catch (SQLException var3) {
//        printException("关闭数据库处理命令异常", var3);
//    }
//}
//
////********************************************************************
///**
// * @param stmt
// * @param rs
// *********************************************************************/
//public static void close(Statement stmt, ResultSet rs) {
//    try {
//        if (rs != null) {
//            rs.close();
//        }
//        if (stmt != null) {
//            stmt.close();
//        }
//    } catch (SQLException var3) {
//        printException("关闭数据库处理命令异常", var3);
//    }
//}
//
//----------------------------------------------------------------------------------------------------------
//
//        stmt.close();
//        } catch (SQLException var3) {
//printException("关闭数据库处理命令异常", var3);
//        }
//                }
//
////********************************************************************
///**
// * @Description 创建数据库执行操作，返回受影响的行数
// * @param connection: 数据库连接
// * @param sql: 执行语句
// * @param params: SQL入参
// * @return int result
// *********************************************************************/
//public static int executeUpdate(Connection connection, String sql, Object[] params) {
//    // 创建链接
//    Connection con = connection;
//    PreparedStatement pstmt = null;
//    int result = 0;
//    try {
//        Reporter.log("1#执行SQL语句#" + sql);
//        Reporter.log("1#执行SQL参数#" + Arrays.toString(params));
//
//        // 预编译sql语句，防止sql注入
//        pstmt = con.prepareStatement(sql);
//        // 传递参数，如果参数存在
//        if (params != null) {
//            // 进行循环传参
//            for (int i = 0; i < params.length; ++i) {
//                pstmt.setObject(i + 1, params[i]);
//            }
//        }
//
//        long start = System.currentTimeMillis();
//
//        ----------------------------------------------------------------------------------------------------------
//
//                System.currentTimeMillis();
//        // 执行sql语句，返回受影响行数
//        result = pstmt.executeUpdate();
//        long end = System.currentTimeMillis();
//
//        Reporter.log("1#执行SQL耗时#" + (double) (end - start) / 1000 + "s");
//    } catch (SQLException var10) {
//        Reporter.log("1#执行SQL异常#" + var10.getMessage(), true);
//        printException("错误日志", var10);
//    } finally {
//        close((PreparedStatement) pstmt, (ResultSet) null);
//    }
//    return result;
//}
//
///**
// * @param connection
// * @param sql
// * @return
// */
//public static int executeUpdate(Connection connection, String sql) {
//    Connection con = connection;
//    Statement stmt = null;
//    int result = 0;
//    try {
//        Reporter.log("1#执行SQL语句#" + sql);
//
//        stmt = con.createStatement();
//        long start = Calendar.getInstance().getTimeInMillis();
//        result = stmt.executeUpdate(sql);
//        long end = Calendar.getInstance().getTimeInMillis();
//
//        Reporter.log("1#执行SQL耗时#" + (double) (end - start) / 1000 + "s");
//    } catch (SQLException var9) {
//        Reporter.log("1#执行SQL异常#" + var9.getMessage(), true);
//        printException("错误日志", var9);
//    } finally {
//        close((Statement) stmt, (ResultSet) null);
//    }
//    return result;
//}
//
//----------------------------------------------------------------------------------------------------------
//
//printException("错误日志", var9);
//    } finally {
//close((Statement) stmt, (ResultSet) null);
//        }
//        return result;
//}
//
////********************************************************************
///**
// * @Description 进行数据的查询，通过自建泛型RowMap，进行数据类型的定义
// * @Connection connection: 数据库连接
// * @param sql: 执行的SQL语句
// * @param params: SQL入参
// * @return list<T>
// *********************************************************************/
//public static ArrayList<Map<String, Object>> executeQuery(Connection connection, String sql, String column,
//                                                          Object[] params) {
//    // 创建list
//    ArrayList<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
//    // 创建链接
//    Connection con = connection;
//    PreparedStatement pstmt = null;
//    ResultSet rs = null;
//    try {
//        Reporter.log("1#执行SQL语句#" + sql);
//        Reporter.log("1#执行SQL参数#" + Arrays.toString(params));
//
//        if (column != null) {
//            sql = sql.replace("*", column);
//        }
//
//        long start = Calendar.getInstance().getTimeInMillis();
//        // 绑定sql语句
//        pstmt = con.prepareStatement(sql);
//
//        ----------------------------------------------------------------------------------------------------------
//
//        long end = Calendar.getInstance().getTimeInMillis();
//        Reporter.log("1#执行SQL耗时#" + (double) (end - start) / 1000 + "s");
//
//        if (params != null) {
//            for (int i = 0; i < params.length; ++i) {
//                pstmt.setObject(i + 1, params[i]);
//            }
//        }
//
//        // 执行语句，用结果集接收
//        rs = pstmt.executeQuery();
//        // 获取结果集属性
//        ResultSetMetaData resultSetMetaData = rs.getMetaData();
//        CaseInsensitiveMap rowMap;
//        for (int columnCount = resultSetMetaData.getColumnCount(); rs.next(); list.add(rowMap)) {
//            rowMap = new CaseInsensitiveMap();
//            for (int i = 1; i <= columnCount; ++i) {
//                rowMap.put(resultSetMetaData.getColumnName(i), rs.getObject(i));
//            }
//        }
//    } catch (SQLException var17) {
//        Reporter.log("1#查询SQL异常#" + var17.getMessage(), true);
//        printException("错误日志", var17);
//    } finally {
//        close(pstmt, rs);
//    }
//    return list;
//}
//
////********************************************************************
///**
// * @Description
// * @param connection
// * @param sql
// * @param column
// * @param params
// * @return
// *********************************************************************/
//
//----------------------------------------------------------------------------------------------------------
//
//public static String executeQueryBySingle(Connection connection, String sql, String column, Object[] params) {
//    Connection con = connection;
//    PreparedStatement st = null;
//    ResultSet rs = null;
//    String excepString = "";
//    String outputString = null;
//    try {
//        Reporter.log("1#执行SQL语句#" + sql);
//        Reporter.log("1#执行SQL参数#" + Arrays.toString(params));
//
//        long start = Calendar.getInstance().getTimeInMillis();
//        st = con.prepareStatement(sql);
//        long end = Calendar.getInstance().getTimeInMillis();
//        Reporter.log("1#执行SQL耗时#" + (double) (end - start) / 1000 + "s");
//
//        List paramsList = new ArrayList();
//        if (params != null && params.length > 0) {
//            for (int i = 0; i < params.length; i++) {
//                st.setObject(i + 1, params[i]);
//                paramsList.add(params[i]);
//            }
//        }
//
//        rs = st.executeQuery();
//        ResultSetMetaData resultSetMetaData = rs.getMetaData();
//        // 返回列数
//        int columnCount = resultSetMetaData.getColumnCount();
//        // 返回行数
//        int rowCount = 0;
//        while (rs.next()) {
//            rowCount++;
//            // 如果查询字段不为空，则从根据查询字段存储map
//            if (column != null) {
//                // 解析要查询的字段名和查询
//
//                ----------------------------------------------------------------------------------------------------------
//
//                        String[] columnName = column.split(",");
//                for (int i = 0; i < columnName.length; i++) {
//                    String columnValue = rs.getObject(columnName[i]) + "";
//                    excepString = excepString + columnValue;
//                }
//            } else {
//                // 如果查询字段为空，则查询并存储所有字段值
//                for (int i = 1; i <= columnCount; i++) {
//                    String columnValue0 = rs.getObject(i) + "";
//                    excepString = excepString + columnValue0;
//                }
//            }
//            rowCount++;
//            if (rowCount >= 2) {
//                break;
//            }
//        }
//        String sqloutput = getQueryString(sql, params);
//        sqloutput = sqloutput.replace("*", "").replace("=", "=");
//        if (rowCount == 1) {
//            outputString = excepString;
//        } else if (rowCount == 0) {
//            outputString = "查询返回结果为空 sql为" + sqloutput;
//        } else {
//            outputString = "查询返回结果大于1条 sql为" + sqloutput;
//        }
//    } catch (SQLException ee) {
//        Reporter.log("1#查询SQL异常#" + ee.getMessage(), true);
//        printException("错误日志", ee);
//    }
//    return outputString;
//
//    ----------------------------------------------------------------------------------------------------------
//
//// 拼接sql跟参数，输出完整的sql语句
//
//    /**
//     * @Description
//     * @param sqlTemplate
//     * @param parameterValues
//     * @return
//     */
//    public static String getQueryString(String sqlTemplate, Object[] parameterValues) {
//        int len = sqlTemplate.length();
//        StringBuffer t = new StringBuffer(len * 2);
//
//        if (parameterValues != null) {
//            int i = 1, limit = 0, base = 0;
//            while ((limit = sqlTemplate.indexOf('?', limit)) != -1) {
//                t.append(sqlTemplate.substring(base, limit));
//                t.append(parameterValues[i - 1]);
//                i++;
//                limit++;
//                base = limit;
//            }
//            if (base < len) {
//                t.append(sqlTemplate.substring(base));
//            }
//        }
//        return t.toString();
//    }
//
//    /**
//     * @Description
//     * @param connection
//     * @param sql
//     * @param params
//     * @return
//     */
//    public static ArrayList<Map<String, Object>> executeQuery(Connection connection, String sql, Object[] params) {
//
//        ----------------------------------------------------------------------------------------------------------
//
//                String sql, Object[] params) {
//            // 创建list
//            ArrayList<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
//            // 创建链接
//            Connection con = connection;
//            PreparedStatement pstmt = null;
//            ResultSet rs = null;
//            try {
//                Reporter.log("1#执行SQL语句#" + sql);
//                Reporter.log("1#执行SQL参数#" + Arrays.toString(params));
//
//                long start = Calendar.getInstance().getTimeInMillis();
//                // 绑定sql语句
//                pstmt = con.prepareStatement(sql);
//                long end = Calendar.getInstance().getTimeInMillis();
//
//                Reporter.log("1#执行SQL耗时#" + (double) (end - start) / 1000 + "s");
//
//                // 如果参数存在，循环传参
//                if (params != null) {
//                    for (int i = 0; i < params.length; ++i) {
//                        pstmt.setObject(i + 1, params[i]);
//                    }
//                }
//
//                // 执行语句，用结果集接收
//                rs = pstmt.executeQuery();
//                // 获取结果集属性
//                ResultSetMetaData resultSetMetaData = rs.getMetaData();
//                // 获取结果集（属性）中的列数
//                int columnCount = resultSetMetaData.getColumnCount();
//                while (rs.next()) {
//                    // 创建Map对象，CaseInsensitiveMap的key不区分大小写，用于存储查询结果集中每一行的数据
//                    Map<String, Object> rowMap = new CaseInsensitiveMap();
//
//                    ----------------------------------------------------------------------------------------------------------
//
//                            CaseInsensitiveMap();
//                    for (int i = 1; i <= columnCount; ++i) {
//                        // 向map中加入键值对，键的内容为字段名，值的内容为结果集中的对应的内容
//                        rowMap.put(resultSetMetaData.getColumnName(i), rs.getObject(i));
//                    }
//                    list.add(rowMap);
//                }
//            } catch (SQLException var14) {
//                Reporter.log("1#查询SQL异常#" + var14.getMessage(), true);
//                printException("错误日志", var14);
//            } finally {
//                close(pstmt, rs);
//            }
//            return list;
//        }
//
///**
// * @Description
// * @param connection
// * @param sql
// * @return
// */
//        public static ArrayList<Map<String, Object>> executeQuery(Connection connection, String sql) {
//            ArrayList<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
//            Connection con = connection;
//            Statement statement = null;
//            ResultSet rs = null;
//            try {
//                Reporter.log("1#执行SQL语句#" + sql);
//
//                statement = con.createStatement();
//                long start = Calendar.getInstance().getTimeInMillis();
//                rs = statement.executeQuery(sql);
//                long end = Calendar.getInstance().getTimeInMillis();
//
//                ----------------------------------------------------------------------------------------------------------
//
//                        rs = statement.executeQuery(sql);
//                long end = Calendar.getInstance().getTimeInMillis();
//                Reporter.log("1#执行SQL耗时#" + (double) (end - start) / 1000 + "s");
//
//                ResultSetMetaData resultSetMetaData = rs.getMetaData();
//                int columnCount = resultSetMetaData.getColumnCount();
//                while (rs.next()) {
//                    Map<String, Object> rowMap = new CaseInsensitiveMap();
//                    for (int i = 1; i <= columnCount; ++i) {
//                        rowMap.put(resultSetMetaData.getColumnName(i), rs.getObject(i));
//                    }
//                    list.add(rowMap);
//                }
//            } catch (SQLException var13) {
//                Reporter.log("1#查询SQL异常#" + var13.getMessage(), true);
//                printException("错误日志", var13);
//            } finally {
//                close(statement, rs);
//            }
//            return list;
//        }
//
////********************************************************************
///**
// * @Description 进行数据的查询，通过自建泛型RowMap，进行数据类型的定义
// * @Connection connection: 数据库连接
// * @param sql: 执行的SQL语句
// * @return list<T>
// *********************************************************************/
//        public static ArrayList<Map<String, Object>> executeQuery(Connection connection, String sql, String column) {
//            // 创建list
//            ArrayList<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
//            // 创建链接
//            Connection con = connection;
//            PreparedStatement pstmt = null;
//            ResultSet rs = null;
//            try {
//                Reporter.log("1#执行SQL语句#" + sql);
//
//                if (column != null) {
//                    sql = sql.replace("*", column);
//                }
//
//                long start = Calendar.getInstance().getTimeInMillis();
//                // 绑定sql语句
//                pstmt = con.prepareStatement(sql);
//                long end = Calendar.getInstance().getTimeInMillis();
//                Reporter.log("1#执行SQL耗时#" + (double) (end - start) / 1000 + "s");
//
//                // 执行语句，用结果集接收
//                rs = pstmt.executeQuery();
//                // 获取结果集属性
//                ResultSetMetaData resultSetMetaData = rs.getMetaData();
//                // 获取结果集（属性）中的列数
//                int columnCount = resultSetMetaData.getColumnCount();
//                while (rs.next()) {
//                    // 创建Map对象，CaseInsensitiveMap的key不区分大小写，用于存储查询结果集中每一行的数据
//                    Map<String, Object> rowMap = new CaseInsensitiveMap();
//                    for (int i = 1; i <= columnCount; ++i) {
//                        // 向map中加入键值对，键的内容为字段名，值的内容为结果集中的对应的内容
//                        rowMap.put(resultSetMetaData.getColumnName(i), rs.getObject(i));
//                    }
//                    list.add(rowMap);
//                }
//            } catch (SQLException var14) {
//                Reporter.log("1#查询SQL异常#" + var14.getMessage(), true);
//                printException("错误日志", var14);
//            } finally {
//                close(pstmt, rs);
//            }
//            return list;
//        }
//
//        ----------------------------------------------------------------------------------------------------------
//
//                // 创建List
//                ArrayList<Map<String, Object>> list = new ArrayList<>();
//        // 创建链接
//        Connection conn = connection;
//        Statement statement = null;
//        ResultSet rs = null;
//
//        try {
//            Reporter.log("1#执行SQL语句#" + sql);
//
//            // 查询字段column不为空时，重新拼接sql查询语句
//            if (column != null) {
//                sql = sql.replace("*", column);
//            }
//
//            // 获取 Statement 对象
//            statement = conn.createStatement();
//
//            long start = Calendar.getInstance().getTimeInMillis();
//            // 执行语句，用结果集接收
//            rs = statement.executeQuery(sql);
//            long end = Calendar.getInstance().getTimeInMillis();
//
//            Reporter.log("1#执行SQL耗时#" + (double) (end - start) / 1000 + "s");
//
//            // 获取结果集属性
//            ResultSetMetaData resultSetMetaData = rs.getMetaData();
//            // 获取结果集（属性）中的列数
//            int columnCount = resultSetMetaData.getColumnCount();
//
//            while (rs.next()) {
//                // 创建Map对象，CaseInsensitiveMap的key不区分大小写，用于存储查询结果中每一行的数据
//                Map<String, Object> rowMap = new CaseInsensitiveMap<>();
//                for (int i = 1; i <= columnCount; i++) {
//                    // 向map中加入键值对，键的内容为字段名，值的内容为结果集中的对应内容
//                    rowMap.put(resultSetMetaData.getColumnName(i), rs.getObject(i));
//                }
//                list.add(rowMap);
//            }
//        } catch (SQLException var14) {
//            Reporter.log("1#查询SQL异常#" + var14.getMessage(), true);
//            printException("错误日志", var14);
//        } finally {
//            close(statement, rs);
//        }
//        return list;
//    }
//
//    ----------------------------------------------------------------------------------------------------------
//
//            为字段名，值的内容为结果集中的对应的内容
//    rowMap.put(resultSetMetaData.getColumnName(i), rs.getObject(i));
//}
//    list.add(rowMap);
//} catch (SQLException e) {
//        Reporter.log("1#查询SQL异常#" + e.getMessage(), true);
//printException("错误日志", e);
//} finally {
//close(statement, rs);
//}
//        return list;
//}
//
///**
// * @Description 执行单条SQL
// * @param url
// * @param us
// * @param pw
// * @param sql
// * @return
// * @throws SQLException
// * @throws JSONException
// * @throws JSONException
// */
//public static AWResponse executeSQL(String url, String us, String pw, String sql) throws SQLException, JSONException, org.json.JSONException {
//    // 性能测试需要加上请求开始时间
//    Reporter.log("1#Time#" + FunctionSet.getCurrentDate("yyyy-MM-dd HH:mm:ss.SSS"), true);
//    Reporter.log("1#执行SQL语句#" + sql, true);
//
//    // 连接数据库
//    Connection connection = JdbcUtilPerf.getConnection(url, us, pw);
//    //Connection connection = DBManagePerf.openConnection(url, us, pw);
//    Reporter.log("1#连接数据库#" + connection, true);
//
//    ----------------------------------------------------------------------------------------------------------
//
//            org.json.JSONObject body = new org.json.JSONObject();
//    AWResponse awResponse = new AWResponse();
//
//// 判断SQL类型选择方法执行
//    selectSQLFun(connection, sql, body);
//
//    awResponse.setResponseBody(body.toString());
//
//// 性能测试需要加上请求结束时间
//    Reporter.log("1#EndTime#" + FunctionSet.getCurrentDate("yyyy-MM-dd HH:mm:ss.SSS"), true);
//
//// 关闭数据库
//    connection.close();
////DBManagerPerf.closeConnection(connection);
//
//    return awResponse;
//}
//
///**
// * @Description 执行多条SQL
// * @param url
// * @param us
// * @param pw
// * @param sqls
// * @return
// * @throws SQLException
// * @throws JSONException
// * @throws JSONException
// */
//public static AWResponse executeSQLs(String url, String us, String pw, String sqls) throws SQLException, JSONException, org.json.JSONException {
//    // 性能测试需要加上请求开始时间
//    Reporter.log("1#Time#" + FunctionSet.getCurrentDate("yyyy-MM-dd HH:mm:ss.SSS"), true);
//
//    // 连接数据库
//    Connection connection = JdbcUtilPerf.getConnection(url, us, pw);
//
//    ----------------------------------------------------------------------------------------------------------
//
//            DBManagerPerf.openConnection(url, us, pw);
////Reporter.log("1#连接数据库#" + connection, true);
//
//    AWResponse awResponse = new AWResponse();
//
//    ArrayList<org.json.JSONObject> arrayList = new ArrayList();
//
//    JSONArray jsonArraySQL = JSONArray.parseArray(sqls);
//
//    for (Object obj : jsonArraySQL) {
//        String sql = String.valueOf(obj);
//        Reporter.log("1#执行SQL语句#" + sql, true);
//
//        org.json.JSONObject body = new org.json.JSONObject();
//        selectSQLFun(connection, sql, body);
//
//        arrayList.add(body);
//    }
//
//    awResponse.setResponseBody(arrayList.toString());
//
//    Reporter.log("1#EndTime#" + FunctionSet.getCurrentDate("yyyy-MM-dd HH:mm:ss.SSS"), true);
//
//// 关闭数据库
//    connection.close();
////DBManagerPerf.closeConnection(connection);
//
//    return awResponse;
//}
//
///*
// * @Description 判断SQL类型选择执行方法
// */
//public static org.json.JSONObject selectSQLFun(Connection connection, String sql, org.json.JSONObject body) throws SQLException, JSONException {
//
//    ----------------------------------------------------------------------------------------------------------
//
//throws SQLException, JSONException, org.json.JSONException {
//        String sqlLower = sql.toLowerCase();
//
//        if (sqlLower.startsWith("select")) {
//            //ArrayList list = executeQuery(connection, sql);
//            ResultSet rs = DBManagerPerf.query(connection, sql, null);
//            org.json.JSONArray jsonArray = getJSONArray(rs);
//
//            rs.last();
//            //awResponse.setReturnCode(200);
//            body.put("message", "查询数据 " + rs.getRow() + " 条");
//            body.put("results", jsonArray.toString());
//
//        } else if (sqlLower.startsWith("insert")) {
//            //int result = executeUpdate(connection, sql, null);
//            int rs = DBManagerPerf.update(connection, sql, null);
//            body.put("message", "添加数据 " + rs + " 条");
//
//        } else if (sqlLower.startsWith("update")) {
//            //int result = executeUpdate(connection, sql, null);
//            int rs = DBManagerPerf.update(connection, sql, null);
//            body.put("message", "更新数据 " + rs + " 条");
//
//        } else if (sqlLower.startsWith("delete")) {
//            //int result = executeUpdate(connection, sql, null);
//            int rs = DBManagerPerf.update(connection, sql, null);
//            body.put("message", "删除数据 " + rs + " 条");
//        }
//        return body;
//    }
//
//    ----------------------------------------------------------------------------------------------------------
//
//            DBManagerPerf.update(connection, sql, null);
//    body.put("message", "删除数据 " + rs + " 条");
//} else {
////int result = executeUpdate(connection, sql, null);
//int rs = DBManagerPerf.update(connection, sql, null);
//    body.put("message", "影响数据 " + rs + " 条");
//}
//        return body;
//}
//
///*
// * @Description 将查询数据库结果集转化成json字符串
// */
//public static org.json.JSONArray getJSONArray(ResultSet rs) throws JSONException, org.json.JSONException {
//    org.json.JSONArray jsonArray = new org.json.JSONArray();
//
//    // 获取列数
//    ResultSetMetaData metaData = null;
//    try {
//        metaData = rs.getMetaData();
//        int columnCount = metaData.getColumnCount();
//
//        // 遍历ResultSet中的每条数据
//        while (rs.next()) { // boolean next() 将光标从当前位置向前移一行。返回: 如果新的当前行有效，则返回 true；如果不存在下一行，则返回 false
//            org.json.JSONObject jsonObj = new org.json.JSONObject();
//            // 遍历每一列
//            for (int i = 1; i <= columnCount; i++) {
//                String columnName = metaData.getColumnLabel(i);
//                String value = rs.getString(columnName);
//                jsonObj.put(columnName, value);
//            }
//            jsonArray.put(jsonObj);
//        }
//    } catch (SQLException e) {
//        e.printStackTrace();
//    }
//    return jsonArray;
//}
//
//----------------------------------------------------------------------------------------------------------
//
//        rs.getString(columnName);
//        jsonObj.put(columnName, value);
//    }
//            // jsonArray.add(jsonObj); //引包 com.alibaba.fastjson.JSONArray;
//            jsonArray.put(jsonObj); // 引包 org.json.JSONArray;
//}
//
////        for (int count = columnCount; rs.next(); jsonArray.put(jsonObj)) {
////            for (int i = 1; i <= columnCount; ++i) {
////                String columnName = metaData.getColumnLabel(i);
////                String value = rs.getString(columnName);
////                jsonObj.put(columnName, value);
////            }
////        }
//
//        } catch (SQLException e) {
//        e.printStackTrace();
//    return null;
//            }
//            return jsonArray;
//}
//        }
